// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.fbainvoice;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.FBAInvoice;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(FBAInvoice.class)
@Setter
@Getter
public class FBAInvoiceSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "FBAInvoice".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("deliveryWarehouse", "w");
    map.put("logisticsprovider1", "lp");
    map.put("logisticsChannel1", "lc");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();
    map.put(
      "invoiceDetailList.shopId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_1 ON RO_1.del_flag = 0 AND RO_1.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_1")
        .setColumnName("shop_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.shipmentCode",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_2 ON RO_2.del_flag = 0 AND RO_2.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_2")
        .setColumnName("shipment_code")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.sku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_3 ON RO_3.del_flag = 0 AND RO_3.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_3")
        .setColumnName("sku")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.name",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_4 ON RO_4.del_flag = 0 AND RO_4.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_4")
        .setColumnName("name")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.name.name",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_5 ON RO_5.del_flag = 0 AND RO_5.id = RO_4.name"
        )
        .setTableAlias("RO_5")
        .setColumnName("name")
        .setDepends(Collections.singletonList("invoiceDetailList.name"))
    );
    map.put(
      "invoiceDetailList.msku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_6 ON RO_6.del_flag = 0 AND RO_6.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_6")
        .setColumnName("msku")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.fnsku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_7 ON RO_7.del_flag = 0 AND RO_7.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_7")
        .setColumnName("fnsku")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.asin",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_8 ON RO_8.del_flag = 0 AND RO_8.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_8")
        .setColumnName("asin")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.parentAsin",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_9 ON RO_9.del_flag = 0 AND RO_9.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_9")
        .setColumnName("parent_asin")
        .setNeedGroupBy(true)
    );
    map.put(
      "logisticsinfo.trackingnumber",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_logistics AS RO_10 ON RO_10.del_flag = 0 AND RO_10.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_10")
        .setColumnName("trackingnumber")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.warehouse",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_detail AS RO_11 ON RO_11.del_flag = 0 AND RO_11.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_11")
        .setColumnName("warehouse")
        .setNeedGroupBy(true)
    );
    map.put(
      "invoiceDetailList.name.sku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_12 ON RO_12.del_flag = 0 AND RO_12.id = RO_4.name"
        )
        .setTableAlias("RO_12")
        .setColumnName("sku")
        .setDepends(Collections.singletonList("invoiceDetailList.name"))
    );
    map.put(
      "logisticsinfo.logisticsnumber",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN fba_invoice_logistics AS RO_13 ON RO_13.del_flag = 0 AND RO_13.parent_f_b_a_invoice = t.id"
        )
        .setTableAlias("RO_13")
        .setColumnName("logisticsnumber")
        .setNeedGroupBy(true)
    );

    return map;
  }

  private Long invoiceDetailList_shopId;
  private List<String> invoiceDetailList_shopIdInList;
  private String invoiceDetailList_shipmentCode;
  private List<String> invoiceDetailList_shipmentCodeInList;
  private String invoiceDetailList_sku;
  private List<String> invoiceDetailList_skuInList;
  private String invoiceDetailList_name_name;
  private List<String> invoiceDetailList_name_nameInList;
  private String invoiceDetailList_msku;
  private List<String> invoiceDetailList_mskuInList;
  private String invoiceDetailList_fnsku;
  private List<String> invoiceDetailList_fnskuInList;
  private String invoiceDetailList_asin;
  private List<String> invoiceDetailList_asinInList;
  private String invoiceDetailList_parentAsin;
  private List<String> invoiceDetailList_parentAsinInList;
  private String logisticsinfo_trackingnumber;
  private List<String> logisticsinfo_trackingnumberInList;
  private Long invoiceDetailList_warehouse;
  private List<String> invoiceDetailList_warehouseInList;
  private String invoiceDetailList_name_sku;
  private List<String> invoiceDetailList_name_skuInList;
  private String logisticsinfo_logisticsnumber;
  private List<String> logisticsinfo_logisticsnumberInList;

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：FBAInvoice/FBAInvoiceAllView, FBAInvoice/FBAInvoiceDistributedView, FBAInvoice/FBAInvoiceSendView, FBAInvoice/FBAInvoiceHasSendView, FBAInvoice/FBAInvoiceCancelView
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 发货单号(模糊搜索)
   */
  private String inoviceCode;

  /**
   * 发货单号 比较(eq)
   */
  private String inoviceCodeEq;
  /**
   * 发货单号 比较(neq)
   */
  private String inoviceCodeNeq;
  /**
   * 发货单号 比较(gt)
   */
  private String inoviceCodeGt;
  /**
   * 发货单号 比较(gte)
   */
  private String inoviceCodeGte;
  /**
   * 发货单号 比较(lt)
   */
  private String inoviceCodeLt;
  /**
   * 发货单号 比较(lte)
   */
  private String inoviceCodeLte;
  /**
   * 发货单号 比较(contains)
   */
  private String inoviceCodeContains;
  /**
   * 发货单号 比较(notcontains)
   */
  private String inoviceCodeNotcontains;
  /**
   * 发货单号 比较(startswith)
   */
  private String inoviceCodeStartswith;
  /**
   * 发货单号 比较(endswith)
   */
  private String inoviceCodeEndswith;
  /**
   * 发货单号 比较(isnull)
   */
  private Boolean inoviceCodeIsnull;
  /**
   * 发货单号 比较(isnotnull)
   */
  private Boolean inoviceCodeIsnotnull;

  /**
   * 发货单号(精确搜索)
   */
  private List<String> inoviceCodeInList;

  /**
   * 发货仓库
   */
  private Long deliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long deliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long deliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long deliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long deliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long deliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long deliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long deliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long deliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long deliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long deliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean deliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean deliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String deliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String deliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String deliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String deliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String deliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String deliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String deliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String deliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String deliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String deliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean deliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean deliveryWarehouseNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> deliveryWarehouseInList;

  /**
   * 货件号(模糊搜索)
   */
  private String shipmentCode;

  /**
   * 货件号 比较(eq)
   */
  private String shipmentCodeEq;
  /**
   * 货件号 比较(neq)
   */
  private String shipmentCodeNeq;
  /**
   * 货件号 比较(gt)
   */
  private String shipmentCodeGt;
  /**
   * 货件号 比较(gte)
   */
  private String shipmentCodeGte;
  /**
   * 货件号 比较(lt)
   */
  private String shipmentCodeLt;
  /**
   * 货件号 比较(lte)
   */
  private String shipmentCodeLte;
  /**
   * 货件号 比较(contains)
   */
  private String shipmentCodeContains;
  /**
   * 货件号 比较(notcontains)
   */
  private String shipmentCodeNotcontains;
  /**
   * 货件号 比较(startswith)
   */
  private String shipmentCodeStartswith;
  /**
   * 货件号 比较(endswith)
   */
  private String shipmentCodeEndswith;
  /**
   * 货件号 比较(isnull)
   */
  private Boolean shipmentCodeIsnull;
  /**
   * 货件号 比较(isnotnull)
   */
  private Boolean shipmentCodeIsnotnull;

  /**
   * 货件号(精确搜索)
   */
  private List<String> shipmentCodeInList;

  /**
   * 运输方式
   */
  private String transportMode;

  /**
   * 运输方式 比较(eq)
   */
  private String transportModeEq;
  /**
   * 运输方式 比较(neq)
   */
  private String transportModeNeq;
  /**
   * 运输方式 比较(gt)
   */
  private String transportModeGt;
  /**
   * 运输方式 比较(gte)
   */
  private String transportModeGte;
  /**
   * 运输方式 比较(lt)
   */
  private String transportModeLt;
  /**
   * 运输方式 比较(lte)
   */
  private String transportModeLte;
  /**
   * 运输方式 比较(contains)
   */
  private String transportModeContains;
  /**
   * 运输方式 比较(notcontains)
   */
  private String transportModeNotcontains;
  /**
   * 运输方式 比较(startswith)
   */
  private String transportModeStartswith;
  /**
   * 运输方式 比较(endswith)
   */
  private String transportModeEndswith;
  /**
   * 运输方式 比较(isnull)
   */
  private Boolean transportModeIsnull;
  /**
   * 运输方式 比较(isnotnull)
   */
  private Boolean transportModeIsnotnull;

  /**
   * 运输方式(精确搜索)
   */
  private List<String> transportModeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 物流商(模糊搜索)
   */
  private String logisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private String logisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private String logisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private String logisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private String logisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private String logisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private String logisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private String logisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private String logisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private String logisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private String logisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean logisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean logisticsProviderIsnotnull;

  /**
   * 物流商(精确搜索)
   */
  private List<String> logisticsProviderInList;

  /**
   * 物流商单号(模糊搜索)
   */
  private String logisticsTrackingNumber;

  /**
   * 物流商单号 比较(eq)
   */
  private String logisticsTrackingNumberEq;
  /**
   * 物流商单号 比较(neq)
   */
  private String logisticsTrackingNumberNeq;
  /**
   * 物流商单号 比较(gt)
   */
  private String logisticsTrackingNumberGt;
  /**
   * 物流商单号 比较(gte)
   */
  private String logisticsTrackingNumberGte;
  /**
   * 物流商单号 比较(lt)
   */
  private String logisticsTrackingNumberLt;
  /**
   * 物流商单号 比较(lte)
   */
  private String logisticsTrackingNumberLte;
  /**
   * 物流商单号 比较(contains)
   */
  private String logisticsTrackingNumberContains;
  /**
   * 物流商单号 比较(notcontains)
   */
  private String logisticsTrackingNumberNotcontains;
  /**
   * 物流商单号 比较(startswith)
   */
  private String logisticsTrackingNumberStartswith;
  /**
   * 物流商单号 比较(endswith)
   */
  private String logisticsTrackingNumberEndswith;
  /**
   * 物流商单号 比较(isnull)
   */
  private Boolean logisticsTrackingNumberIsnull;
  /**
   * 物流商单号 比较(isnotnull)
   */
  private Boolean logisticsTrackingNumberIsnotnull;

  /**
   * 物流商单号(精确搜索)
   */
  private List<String> logisticsTrackingNumberInList;

  /**
   * 物流渠道(模糊搜索)
   */
  private String logisticsChannel;

  /**
   * 物流渠道 比较(eq)
   */
  private String logisticsChannelEq;
  /**
   * 物流渠道 比较(neq)
   */
  private String logisticsChannelNeq;
  /**
   * 物流渠道 比较(gt)
   */
  private String logisticsChannelGt;
  /**
   * 物流渠道 比较(gte)
   */
  private String logisticsChannelGte;
  /**
   * 物流渠道 比较(lt)
   */
  private String logisticsChannelLt;
  /**
   * 物流渠道 比较(lte)
   */
  private String logisticsChannelLte;
  /**
   * 物流渠道 比较(contains)
   */
  private String logisticsChannelContains;
  /**
   * 物流渠道 比较(notcontains)
   */
  private String logisticsChannelNotcontains;
  /**
   * 物流渠道 比较(startswith)
   */
  private String logisticsChannelStartswith;
  /**
   * 物流渠道 比较(endswith)
   */
  private String logisticsChannelEndswith;
  /**
   * 物流渠道 比较(isnull)
   */
  private Boolean logisticsChannelIsnull;
  /**
   * 物流渠道 比较(isnotnull)
   */
  private Boolean logisticsChannelIsnotnull;

  /**
   * 物流渠道(精确搜索)
   */
  private List<String> logisticsChannelInList;

  /**
   * 物流信息(模糊搜索)
   */
  private String logisticsInfo;

  /**
   * 物流信息 比较(eq)
   */
  private String logisticsInfoEq;
  /**
   * 物流信息 比较(neq)
   */
  private String logisticsInfoNeq;
  /**
   * 物流信息 比较(gt)
   */
  private String logisticsInfoGt;
  /**
   * 物流信息 比较(gte)
   */
  private String logisticsInfoGte;
  /**
   * 物流信息 比较(lt)
   */
  private String logisticsInfoLt;
  /**
   * 物流信息 比较(lte)
   */
  private String logisticsInfoLte;
  /**
   * 物流信息 比较(contains)
   */
  private String logisticsInfoContains;
  /**
   * 物流信息 比较(notcontains)
   */
  private String logisticsInfoNotcontains;
  /**
   * 物流信息 比较(startswith)
   */
  private String logisticsInfoStartswith;
  /**
   * 物流信息 比较(endswith)
   */
  private String logisticsInfoEndswith;
  /**
   * 物流信息 比较(isnull)
   */
  private Boolean logisticsInfoIsnull;
  /**
   * 物流信息 比较(isnotnull)
   */
  private Boolean logisticsInfoIsnotnull;

  /**
   * 物流信息(精确搜索)
   */
  private List<String> logisticsInfoInList;

  /**
   * 发货人(模糊搜索)
   */
  private String sendName;

  /**
   * 发货人 比较(eq)
   */
  private String sendNameEq;
  /**
   * 发货人 比较(neq)
   */
  private String sendNameNeq;
  /**
   * 发货人 比较(gt)
   */
  private String sendNameGt;
  /**
   * 发货人 比较(gte)
   */
  private String sendNameGte;
  /**
   * 发货人 比较(lt)
   */
  private String sendNameLt;
  /**
   * 发货人 比较(lte)
   */
  private String sendNameLte;
  /**
   * 发货人 比较(contains)
   */
  private String sendNameContains;
  /**
   * 发货人 比较(notcontains)
   */
  private String sendNameNotcontains;
  /**
   * 发货人 比较(startswith)
   */
  private String sendNameStartswith;
  /**
   * 发货人 比较(endswith)
   */
  private String sendNameEndswith;
  /**
   * 发货人 比较(isnull)
   */
  private Boolean sendNameIsnull;
  /**
   * 发货人 比较(isnotnull)
   */
  private Boolean sendNameIsnotnull;

  /**
   * 发货人(精确搜索)
   */
  private List<String> sendNameInList;

  /**
   * 最早发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sendTimeStart;

  /**
   * 最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sendTimeEnd;

  /**
   * 发货时间 比较(eq)
   */
  private Date sendTimeEq;
  /**
   * 发货时间 比较(neq)
   */
  private Date sendTimeNeq;
  /**
   * 发货时间 比较(gt)
   */
  private Date sendTimeGt;
  /**
   * 发货时间 比较(gte)
   */
  private Date sendTimeGte;
  /**
   * 发货时间 比较(lt)
   */
  private Date sendTimeLt;
  /**
   * 发货时间 比较(lte)
   */
  private Date sendTimeLte;
  /**
   * 发货时间 比较(contains)
   */
  private Date sendTimeContains;
  /**
   * 发货时间 比较(notcontains)
   */
  private Date sendTimeNotcontains;
  /**
   * 发货时间 比较(startswith)
   */
  private Date sendTimeStartswith;
  /**
   * 发货时间 比较(endswith)
   */
  private Date sendTimeEndswith;
  /**
   * 发货时间 比较(isnull)
   */
  private Boolean sendTimeIsnull;
  /**
   * 发货时间 比较(isnotnull)
   */
  private Boolean sendTimeIsnotnull;

  /**
   * 最早预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectReachTimeStart;

  /**
   * 最晚预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectReachTimeEnd;

  /**
   * 预计到货时间 比较(eq)
   */
  private Date expectReachTimeEq;
  /**
   * 预计到货时间 比较(neq)
   */
  private Date expectReachTimeNeq;
  /**
   * 预计到货时间 比较(gt)
   */
  private Date expectReachTimeGt;
  /**
   * 预计到货时间 比较(gte)
   */
  private Date expectReachTimeGte;
  /**
   * 预计到货时间 比较(lt)
   */
  private Date expectReachTimeLt;
  /**
   * 预计到货时间 比较(lte)
   */
  private Date expectReachTimeLte;
  /**
   * 预计到货时间 比较(contains)
   */
  private Date expectReachTimeContains;
  /**
   * 预计到货时间 比较(notcontains)
   */
  private Date expectReachTimeNotcontains;
  /**
   * 预计到货时间 比较(startswith)
   */
  private Date expectReachTimeStartswith;
  /**
   * 预计到货时间 比较(endswith)
   */
  private Date expectReachTimeEndswith;
  /**
   * 预计到货时间 比较(isnull)
   */
  private Boolean expectReachTimeIsnull;
  /**
   * 预计到货时间 比较(isnotnull)
   */
  private Boolean expectReachTimeIsnotnull;

  /**
   * 最早实际发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date realitySendTimeStart;

  /**
   * 最晚实际发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date realitySendTimeEnd;

  /**
   * 实际发货时间 比较(eq)
   */
  private Date realitySendTimeEq;
  /**
   * 实际发货时间 比较(neq)
   */
  private Date realitySendTimeNeq;
  /**
   * 实际发货时间 比较(gt)
   */
  private Date realitySendTimeGt;
  /**
   * 实际发货时间 比较(gte)
   */
  private Date realitySendTimeGte;
  /**
   * 实际发货时间 比较(lt)
   */
  private Date realitySendTimeLt;
  /**
   * 实际发货时间 比较(lte)
   */
  private Date realitySendTimeLte;
  /**
   * 实际发货时间 比较(contains)
   */
  private Date realitySendTimeContains;
  /**
   * 实际发货时间 比较(notcontains)
   */
  private Date realitySendTimeNotcontains;
  /**
   * 实际发货时间 比较(startswith)
   */
  private Date realitySendTimeStartswith;
  /**
   * 实际发货时间 比较(endswith)
   */
  private Date realitySendTimeEndswith;
  /**
   * 实际发货时间 比较(isnull)
   */
  private Boolean realitySendTimeIsnull;
  /**
   * 实际发货时间 比较(isnotnull)
   */
  private Boolean realitySendTimeIsnotnull;

  /**
   * 物流中心编码(模糊搜索)
   */
  private String logisticsCenterCode;

  /**
   * 物流中心编码 比较(eq)
   */
  private String logisticsCenterCodeEq;
  /**
   * 物流中心编码 比较(neq)
   */
  private String logisticsCenterCodeNeq;
  /**
   * 物流中心编码 比较(gt)
   */
  private String logisticsCenterCodeGt;
  /**
   * 物流中心编码 比较(gte)
   */
  private String logisticsCenterCodeGte;
  /**
   * 物流中心编码 比较(lt)
   */
  private String logisticsCenterCodeLt;
  /**
   * 物流中心编码 比较(lte)
   */
  private String logisticsCenterCodeLte;
  /**
   * 物流中心编码 比较(contains)
   */
  private String logisticsCenterCodeContains;
  /**
   * 物流中心编码 比较(notcontains)
   */
  private String logisticsCenterCodeNotcontains;
  /**
   * 物流中心编码 比较(startswith)
   */
  private String logisticsCenterCodeStartswith;
  /**
   * 物流中心编码 比较(endswith)
   */
  private String logisticsCenterCodeEndswith;
  /**
   * 物流中心编码 比较(isnull)
   */
  private Boolean logisticsCenterCodeIsnull;
  /**
   * 物流中心编码 比较(isnotnull)
   */
  private Boolean logisticsCenterCodeIsnotnull;

  /**
   * 物流中心编码(精确搜索)
   */
  private List<String> logisticsCenterCodeInList;

  /**
   * 付款状态
   */
  private String paymentStatus;

  /**
   * 付款状态 比较(eq)
   */
  private String paymentStatusEq;
  /**
   * 付款状态 比较(neq)
   */
  private String paymentStatusNeq;
  /**
   * 付款状态 比较(gt)
   */
  private String paymentStatusGt;
  /**
   * 付款状态 比较(gte)
   */
  private String paymentStatusGte;
  /**
   * 付款状态 比较(lt)
   */
  private String paymentStatusLt;
  /**
   * 付款状态 比较(lte)
   */
  private String paymentStatusLte;
  /**
   * 付款状态 比较(contains)
   */
  private String paymentStatusContains;
  /**
   * 付款状态 比较(notcontains)
   */
  private String paymentStatusNotcontains;
  /**
   * 付款状态 比较(startswith)
   */
  private String paymentStatusStartswith;
  /**
   * 付款状态 比较(endswith)
   */
  private String paymentStatusEndswith;
  /**
   * 付款状态 比较(isnull)
   */
  private Boolean paymentStatusIsnull;
  /**
   * 付款状态 比较(isnotnull)
   */
  private Boolean paymentStatusIsnotnull;

  /**
   * 付款状态(精确搜索)
   */
  private List<String> paymentStatusInList;

  /**
   * 发货状态
   */
  private String invoiceStatus;

  /**
   * 发货状态 比较(eq)
   */
  private String invoiceStatusEq;
  /**
   * 发货状态 比较(neq)
   */
  private String invoiceStatusNeq;
  /**
   * 发货状态 比较(gt)
   */
  private String invoiceStatusGt;
  /**
   * 发货状态 比较(gte)
   */
  private String invoiceStatusGte;
  /**
   * 发货状态 比较(lt)
   */
  private String invoiceStatusLt;
  /**
   * 发货状态 比较(lte)
   */
  private String invoiceStatusLte;
  /**
   * 发货状态 比较(contains)
   */
  private String invoiceStatusContains;
  /**
   * 发货状态 比较(notcontains)
   */
  private String invoiceStatusNotcontains;
  /**
   * 发货状态 比较(startswith)
   */
  private String invoiceStatusStartswith;
  /**
   * 发货状态 比较(endswith)
   */
  private String invoiceStatusEndswith;
  /**
   * 发货状态 比较(isnull)
   */
  private Boolean invoiceStatusIsnull;
  /**
   * 发货状态 比较(isnotnull)
   */
  private Boolean invoiceStatusIsnotnull;

  /**
   * 发货状态(精确搜索)
   */
  private List<String> invoiceStatusInList;

  /**
   * 打印状态
   */
  private String printStatus;

  /**
   * 打印状态 比较(eq)
   */
  private String printStatusEq;
  /**
   * 打印状态 比较(neq)
   */
  private String printStatusNeq;
  /**
   * 打印状态 比较(gt)
   */
  private String printStatusGt;
  /**
   * 打印状态 比较(gte)
   */
  private String printStatusGte;
  /**
   * 打印状态 比较(lt)
   */
  private String printStatusLt;
  /**
   * 打印状态 比较(lte)
   */
  private String printStatusLte;
  /**
   * 打印状态 比较(contains)
   */
  private String printStatusContains;
  /**
   * 打印状态 比较(notcontains)
   */
  private String printStatusNotcontains;
  /**
   * 打印状态 比较(startswith)
   */
  private String printStatusStartswith;
  /**
   * 打印状态 比较(endswith)
   */
  private String printStatusEndswith;
  /**
   * 打印状态 比较(isnull)
   */
  private Boolean printStatusIsnull;
  /**
   * 打印状态 比较(isnotnull)
   */
  private Boolean printStatusIsnotnull;

  /**
   * 打印状态(精确搜索)
   */
  private List<String> printStatusInList;

  /**
   * 打印数量
   */
  private Integer printNum;

  /**
   * 最小打印数量
   */
  private Integer printNumMin;

  /**
   * 最大打印数量
   */
  private Integer printNumMax;

  /**
   * 打印数量 比较(eq)
   */
  private Integer printNumEq;
  /**
   * 打印数量 比较(neq)
   */
  private Integer printNumNeq;
  /**
   * 打印数量 比较(gt)
   */
  private Integer printNumGt;
  /**
   * 打印数量 比较(gte)
   */
  private Integer printNumGte;
  /**
   * 打印数量 比较(lt)
   */
  private Integer printNumLt;
  /**
   * 打印数量 比较(lte)
   */
  private Integer printNumLte;
  /**
   * 打印数量 比较(contains)
   */
  private Integer printNumContains;
  /**
   * 打印数量 比较(notcontains)
   */
  private Integer printNumNotcontains;
  /**
   * 打印数量 比较(startswith)
   */
  private Integer printNumStartswith;
  /**
   * 打印数量 比较(endswith)
   */
  private Integer printNumEndswith;
  /**
   * 打印数量 比较(isnull)
   */
  private Boolean printNumIsnull;
  /**
   * 打印数量 比较(isnotnull)
   */
  private Boolean printNumIsnotnull;

  /**
   * 拣货状态
   */
  private String isPick;

  /**
   * 拣货状态 比较(eq)
   */
  private String isPickEq;
  /**
   * 拣货状态 比较(neq)
   */
  private String isPickNeq;
  /**
   * 拣货状态 比较(gt)
   */
  private String isPickGt;
  /**
   * 拣货状态 比较(gte)
   */
  private String isPickGte;
  /**
   * 拣货状态 比较(lt)
   */
  private String isPickLt;
  /**
   * 拣货状态 比较(lte)
   */
  private String isPickLte;
  /**
   * 拣货状态 比较(contains)
   */
  private String isPickContains;
  /**
   * 拣货状态 比较(notcontains)
   */
  private String isPickNotcontains;
  /**
   * 拣货状态 比较(startswith)
   */
  private String isPickStartswith;
  /**
   * 拣货状态 比较(endswith)
   */
  private String isPickEndswith;
  /**
   * 拣货状态 比较(isnull)
   */
  private Boolean isPickIsnull;
  /**
   * 拣货状态 比较(isnotnull)
   */
  private Boolean isPickIsnotnull;

  /**
   * 拣货状态(精确搜索)
   */
  private List<String> isPickInList;

  /**
   * 最早拣货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickTimeStart;

  /**
   * 最晚拣货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date pickTimeEnd;

  /**
   * 拣货时间 比较(eq)
   */
  private Date pickTimeEq;
  /**
   * 拣货时间 比较(neq)
   */
  private Date pickTimeNeq;
  /**
   * 拣货时间 比较(gt)
   */
  private Date pickTimeGt;
  /**
   * 拣货时间 比较(gte)
   */
  private Date pickTimeGte;
  /**
   * 拣货时间 比较(lt)
   */
  private Date pickTimeLt;
  /**
   * 拣货时间 比较(lte)
   */
  private Date pickTimeLte;
  /**
   * 拣货时间 比较(contains)
   */
  private Date pickTimeContains;
  /**
   * 拣货时间 比较(notcontains)
   */
  private Date pickTimeNotcontains;
  /**
   * 拣货时间 比较(startswith)
   */
  private Date pickTimeStartswith;
  /**
   * 拣货时间 比较(endswith)
   */
  private Date pickTimeEndswith;
  /**
   * 拣货时间 比较(isnull)
   */
  private Boolean pickTimeIsnull;
  /**
   * 拣货时间 比较(isnotnull)
   */
  private Boolean pickTimeIsnotnull;

  /**
   * 最早计划发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shipmentPlanTimeStart;

  /**
   * 最晚计划发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shipmentPlanTimeEnd;

  /**
   * 计划发货时间 比较(eq)
   */
  private Date shipmentPlanTimeEq;
  /**
   * 计划发货时间 比较(neq)
   */
  private Date shipmentPlanTimeNeq;
  /**
   * 计划发货时间 比较(gt)
   */
  private Date shipmentPlanTimeGt;
  /**
   * 计划发货时间 比较(gte)
   */
  private Date shipmentPlanTimeGte;
  /**
   * 计划发货时间 比较(lt)
   */
  private Date shipmentPlanTimeLt;
  /**
   * 计划发货时间 比较(lte)
   */
  private Date shipmentPlanTimeLte;
  /**
   * 计划发货时间 比较(contains)
   */
  private Date shipmentPlanTimeContains;
  /**
   * 计划发货时间 比较(notcontains)
   */
  private Date shipmentPlanTimeNotcontains;
  /**
   * 计划发货时间 比较(startswith)
   */
  private Date shipmentPlanTimeStartswith;
  /**
   * 计划发货时间 比较(endswith)
   */
  private Date shipmentPlanTimeEndswith;
  /**
   * 计划发货时间 比较(isnull)
   */
  private Boolean shipmentPlanTimeIsnull;
  /**
   * 计划发货时间 比较(isnotnull)
   */
  private Boolean shipmentPlanTimeIsnotnull;

  /**
   * 物流状态(模糊搜索)
   */
  private String logisticsStatus;

  /**
   * 物流状态 比较(eq)
   */
  private String logisticsStatusEq;
  /**
   * 物流状态 比较(neq)
   */
  private String logisticsStatusNeq;
  /**
   * 物流状态 比较(gt)
   */
  private String logisticsStatusGt;
  /**
   * 物流状态 比较(gte)
   */
  private String logisticsStatusGte;
  /**
   * 物流状态 比较(lt)
   */
  private String logisticsStatusLt;
  /**
   * 物流状态 比较(lte)
   */
  private String logisticsStatusLte;
  /**
   * 物流状态 比较(contains)
   */
  private String logisticsStatusContains;
  /**
   * 物流状态 比较(notcontains)
   */
  private String logisticsStatusNotcontains;
  /**
   * 物流状态 比较(startswith)
   */
  private String logisticsStatusStartswith;
  /**
   * 物流状态 比较(endswith)
   */
  private String logisticsStatusEndswith;
  /**
   * 物流状态 比较(isnull)
   */
  private Boolean logisticsStatusIsnull;
  /**
   * 物流状态 比较(isnotnull)
   */
  private Boolean logisticsStatusIsnotnull;

  /**
   * 物流状态(精确搜索)
   */
  private List<String> logisticsStatusInList;

  /**
   * VAT税号(模糊搜索)
   */
  private String vat;

  /**
   * VAT税号 比较(eq)
   */
  private String vatEq;
  /**
   * VAT税号 比较(neq)
   */
  private String vatNeq;
  /**
   * VAT税号 比较(gt)
   */
  private String vatGt;
  /**
   * VAT税号 比较(gte)
   */
  private String vatGte;
  /**
   * VAT税号 比较(lt)
   */
  private String vatLt;
  /**
   * VAT税号 比较(lte)
   */
  private String vatLte;
  /**
   * VAT税号 比较(contains)
   */
  private String vatContains;
  /**
   * VAT税号 比较(notcontains)
   */
  private String vatNotcontains;
  /**
   * VAT税号 比较(startswith)
   */
  private String vatStartswith;
  /**
   * VAT税号 比较(endswith)
   */
  private String vatEndswith;
  /**
   * VAT税号 比较(isnull)
   */
  private Boolean vatIsnull;
  /**
   * VAT税号 比较(isnotnull)
   */
  private Boolean vatIsnotnull;

  /**
   * VAT税号(精确搜索)
   */
  private List<String> vatInList;

  /**
   * 负责人(模糊搜索)
   */
  private String principal;

  /**
   * 负责人 比较(eq)
   */
  private String principalEq;
  /**
   * 负责人 比较(neq)
   */
  private String principalNeq;
  /**
   * 负责人 比较(gt)
   */
  private String principalGt;
  /**
   * 负责人 比较(gte)
   */
  private String principalGte;
  /**
   * 负责人 比较(lt)
   */
  private String principalLt;
  /**
   * 负责人 比较(lte)
   */
  private String principalLte;
  /**
   * 负责人 比较(contains)
   */
  private String principalContains;
  /**
   * 负责人 比较(notcontains)
   */
  private String principalNotcontains;
  /**
   * 负责人 比较(startswith)
   */
  private String principalStartswith;
  /**
   * 负责人 比较(endswith)
   */
  private String principalEndswith;
  /**
   * 负责人 比较(isnull)
   */
  private Boolean principalIsnull;
  /**
   * 负责人 比较(isnotnull)
   */
  private Boolean principalIsnotnull;

  /**
   * 负责人(精确搜索)
   */
  private List<String> principalInList;

  /**
   * 创建人(模糊搜索)
   */
  private String lxCreateUser;

  /**
   * 创建人 比较(eq)
   */
  private String lxCreateUserEq;
  /**
   * 创建人 比较(neq)
   */
  private String lxCreateUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private String lxCreateUserGt;
  /**
   * 创建人 比较(gte)
   */
  private String lxCreateUserGte;
  /**
   * 创建人 比较(lt)
   */
  private String lxCreateUserLt;
  /**
   * 创建人 比较(lte)
   */
  private String lxCreateUserLte;
  /**
   * 创建人 比较(contains)
   */
  private String lxCreateUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private String lxCreateUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private String lxCreateUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private String lxCreateUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean lxCreateUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean lxCreateUserIsnotnull;

  /**
   * 创建人(精确搜索)
   */
  private List<String> lxCreateUserInList;

  /**
   * 物流预计时效
   */
  private Integer logisticsExpectedAging;

  /**
   * 最小物流预计时效
   */
  private Integer logisticsExpectedAgingMin;

  /**
   * 最大物流预计时效
   */
  private Integer logisticsExpectedAgingMax;

  /**
   * 物流预计时效 比较(eq)
   */
  private Integer logisticsExpectedAgingEq;
  /**
   * 物流预计时效 比较(neq)
   */
  private Integer logisticsExpectedAgingNeq;
  /**
   * 物流预计时效 比较(gt)
   */
  private Integer logisticsExpectedAgingGt;
  /**
   * 物流预计时效 比较(gte)
   */
  private Integer logisticsExpectedAgingGte;
  /**
   * 物流预计时效 比较(lt)
   */
  private Integer logisticsExpectedAgingLt;
  /**
   * 物流预计时效 比较(lte)
   */
  private Integer logisticsExpectedAgingLte;
  /**
   * 物流预计时效 比较(contains)
   */
  private Integer logisticsExpectedAgingContains;
  /**
   * 物流预计时效 比较(notcontains)
   */
  private Integer logisticsExpectedAgingNotcontains;
  /**
   * 物流预计时效 比较(startswith)
   */
  private Integer logisticsExpectedAgingStartswith;
  /**
   * 物流预计时效 比较(endswith)
   */
  private Integer logisticsExpectedAgingEndswith;
  /**
   * 物流预计时效 比较(isnull)
   */
  private Boolean logisticsExpectedAgingIsnull;
  /**
   * 物流预计时效 比较(isnotnull)
   */
  private Boolean logisticsExpectedAgingIsnotnull;

  /**
   * 分摊方式
   */
  private String allocationType;

  /**
   * 分摊方式 比较(eq)
   */
  private String allocationTypeEq;
  /**
   * 分摊方式 比较(neq)
   */
  private String allocationTypeNeq;
  /**
   * 分摊方式 比较(gt)
   */
  private String allocationTypeGt;
  /**
   * 分摊方式 比较(gte)
   */
  private String allocationTypeGte;
  /**
   * 分摊方式 比较(lt)
   */
  private String allocationTypeLt;
  /**
   * 分摊方式 比较(lte)
   */
  private String allocationTypeLte;
  /**
   * 分摊方式 比较(contains)
   */
  private String allocationTypeContains;
  /**
   * 分摊方式 比较(notcontains)
   */
  private String allocationTypeNotcontains;
  /**
   * 分摊方式 比较(startswith)
   */
  private String allocationTypeStartswith;
  /**
   * 分摊方式 比较(endswith)
   */
  private String allocationTypeEndswith;
  /**
   * 分摊方式 比较(isnull)
   */
  private Boolean allocationTypeIsnull;
  /**
   * 分摊方式 比较(isnotnull)
   */
  private Boolean allocationTypeIsnotnull;

  /**
   * 分摊方式(精确搜索)
   */
  private List<String> allocationTypeInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 附件(模糊搜索)
   */
  private String file;

  /**
   * 附件 比较(eq)
   */
  private String fileEq;
  /**
   * 附件 比较(neq)
   */
  private String fileNeq;
  /**
   * 附件 比较(gt)
   */
  private String fileGt;
  /**
   * 附件 比较(gte)
   */
  private String fileGte;
  /**
   * 附件 比较(lt)
   */
  private String fileLt;
  /**
   * 附件 比较(lte)
   */
  private String fileLte;
  /**
   * 附件 比较(contains)
   */
  private String fileContains;
  /**
   * 附件 比较(notcontains)
   */
  private String fileNotcontains;
  /**
   * 附件 比较(startswith)
   */
  private String fileStartswith;
  /**
   * 附件 比较(endswith)
   */
  private String fileEndswith;
  /**
   * 附件 比较(isnull)
   */
  private Boolean fileIsnull;
  /**
   * 附件 比较(isnotnull)
   */
  private Boolean fileIsnotnull;

  /**
   * 附件(精确搜索)
   */
  private List<String> fileInList;

  /**
   * 是否推送出库单
   */
  private Boolean isOut;

  /**
   * 是否推送出库单
   */
  private String isOutEq;

  /**
   * 是否锁库存
   */
  private String islockinventory;

  /**
   * 是否锁库存 比较(eq)
   */
  private String islockinventoryEq;
  /**
   * 是否锁库存 比较(neq)
   */
  private String islockinventoryNeq;
  /**
   * 是否锁库存 比较(gt)
   */
  private String islockinventoryGt;
  /**
   * 是否锁库存 比较(gte)
   */
  private String islockinventoryGte;
  /**
   * 是否锁库存 比较(lt)
   */
  private String islockinventoryLt;
  /**
   * 是否锁库存 比较(lte)
   */
  private String islockinventoryLte;
  /**
   * 是否锁库存 比较(contains)
   */
  private String islockinventoryContains;
  /**
   * 是否锁库存 比较(notcontains)
   */
  private String islockinventoryNotcontains;
  /**
   * 是否锁库存 比较(startswith)
   */
  private String islockinventoryStartswith;
  /**
   * 是否锁库存 比较(endswith)
   */
  private String islockinventoryEndswith;
  /**
   * 是否锁库存 比较(isnull)
   */
  private Boolean islockinventoryIsnull;
  /**
   * 是否锁库存 比较(isnotnull)
   */
  private Boolean islockinventoryIsnotnull;

  /**
   * 是否锁库存(精确搜索)
   */
  private List<String> islockinventoryInList;

  /**
   * 发货产品(模糊搜索)
   */
  private String productitems;

  /**
   * 发货产品 比较(eq)
   */
  private String productitemsEq;
  /**
   * 发货产品 比较(neq)
   */
  private String productitemsNeq;
  /**
   * 发货产品 比较(gt)
   */
  private String productitemsGt;
  /**
   * 发货产品 比较(gte)
   */
  private String productitemsGte;
  /**
   * 发货产品 比较(lt)
   */
  private String productitemsLt;
  /**
   * 发货产品 比较(lte)
   */
  private String productitemsLte;
  /**
   * 发货产品 比较(contains)
   */
  private String productitemsContains;
  /**
   * 发货产品 比较(notcontains)
   */
  private String productitemsNotcontains;
  /**
   * 发货产品 比较(startswith)
   */
  private String productitemsStartswith;
  /**
   * 发货产品 比较(endswith)
   */
  private String productitemsEndswith;
  /**
   * 发货产品 比较(isnull)
   */
  private Boolean productitemsIsnull;
  /**
   * 发货产品 比较(isnotnull)
   */
  private Boolean productitemsIsnotnull;

  /**
   * 发货产品(精确搜索)
   */
  private List<String> productitemsInList;

  /**
   * 运输方式
   */
  private String modeoftransport;

  /**
   * 运输方式 比较(eq)
   */
  private String modeoftransportEq;
  /**
   * 运输方式 比较(neq)
   */
  private String modeoftransportNeq;
  /**
   * 运输方式 比较(gt)
   */
  private String modeoftransportGt;
  /**
   * 运输方式 比较(gte)
   */
  private String modeoftransportGte;
  /**
   * 运输方式 比较(lt)
   */
  private String modeoftransportLt;
  /**
   * 运输方式 比较(lte)
   */
  private String modeoftransportLte;
  /**
   * 运输方式 比较(contains)
   */
  private String modeoftransportContains;
  /**
   * 运输方式 比较(notcontains)
   */
  private String modeoftransportNotcontains;
  /**
   * 运输方式 比较(startswith)
   */
  private String modeoftransportStartswith;
  /**
   * 运输方式 比较(endswith)
   */
  private String modeoftransportEndswith;
  /**
   * 运输方式 比较(isnull)
   */
  private Boolean modeoftransportIsnull;
  /**
   * 运输方式 比较(isnotnull)
   */
  private Boolean modeoftransportIsnotnull;

  /**
   * 运输方式(精确搜索)
   */
  private List<String> modeoftransportInList;

  /**
   * 物流商
   */
  private Long logisticsprovider1;

  /**
   * 物流商 比较(eq)
   */
  private Long logisticsprovider1Eq;
  /**
   * 物流商 比较(neq)
   */
  private Long logisticsprovider1Neq;
  /**
   * 物流商 比较(gt)
   */
  private Long logisticsprovider1Gt;
  /**
   * 物流商 比较(gte)
   */
  private Long logisticsprovider1Gte;
  /**
   * 物流商 比较(lt)
   */
  private Long logisticsprovider1Lt;
  /**
   * 物流商 比较(lte)
   */
  private Long logisticsprovider1Lte;
  /**
   * 物流商 比较(contains)
   */
  private Long logisticsprovider1Contains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long logisticsprovider1Notcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long logisticsprovider1Startswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long logisticsprovider1Endswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean logisticsprovider1Isnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean logisticsprovider1Isnotnull;
  /**
   * 物流商的物流商 比较(eq)
   */
  private String logisticsprovider1NameEq;
  /**
   * 物流商的物流商 比较(neq)
   */
  private String logisticsprovider1NameNeq;
  /**
   * 物流商的物流商 比较(gt)
   */
  private String logisticsprovider1NameGt;
  /**
   * 物流商的物流商 比较(gte)
   */
  private String logisticsprovider1NameGte;
  /**
   * 物流商的物流商 比较(lt)
   */
  private String logisticsprovider1NameLt;
  /**
   * 物流商的物流商 比较(lte)
   */
  private String logisticsprovider1NameLte;
  /**
   * 物流商的物流商 比较(contains)
   */
  private String logisticsprovider1NameContains;
  /**
   * 物流商的物流商 比较(notcontains)
   */
  private String logisticsprovider1NameNotcontains;
  /**
   * 物流商的物流商 比较(startswith)
   */
  private String logisticsprovider1NameStartswith;
  /**
   * 物流商的物流商 比较(endswith)
   */
  private String logisticsprovider1NameEndswith;
  /**
   * 物流商的物流商 比较(isnull)
   */
  private Boolean logisticsprovider1NameIsnull;
  /**
   * 物流商的物流商 比较(isnotnull)
   */
  private Boolean logisticsprovider1NameIsnotnull;

  /**
   * 物流商(范围搜索)
   */
  private List<Long> logisticsprovider1InList;

  /**
   * 物流渠道
   */
  private Long logisticsChannel1;

  /**
   * 物流渠道 比较(eq)
   */
  private Long logisticsChannel1Eq;
  /**
   * 物流渠道 比较(neq)
   */
  private Long logisticsChannel1Neq;
  /**
   * 物流渠道 比较(gt)
   */
  private Long logisticsChannel1Gt;
  /**
   * 物流渠道 比较(gte)
   */
  private Long logisticsChannel1Gte;
  /**
   * 物流渠道 比较(lt)
   */
  private Long logisticsChannel1Lt;
  /**
   * 物流渠道 比较(lte)
   */
  private Long logisticsChannel1Lte;
  /**
   * 物流渠道 比较(contains)
   */
  private Long logisticsChannel1Contains;
  /**
   * 物流渠道 比较(notcontains)
   */
  private Long logisticsChannel1Notcontains;
  /**
   * 物流渠道 比较(startswith)
   */
  private Long logisticsChannel1Startswith;
  /**
   * 物流渠道 比较(endswith)
   */
  private Long logisticsChannel1Endswith;
  /**
   * 物流渠道 比较(isnull)
   */
  private Boolean logisticsChannel1Isnull;
  /**
   * 物流渠道 比较(isnotnull)
   */
  private Boolean logisticsChannel1Isnotnull;
  /**
   * 物流渠道的物流渠道 比较(eq)
   */
  private String logisticsChannel1NameEq;
  /**
   * 物流渠道的物流渠道 比较(neq)
   */
  private String logisticsChannel1NameNeq;
  /**
   * 物流渠道的物流渠道 比较(gt)
   */
  private String logisticsChannel1NameGt;
  /**
   * 物流渠道的物流渠道 比较(gte)
   */
  private String logisticsChannel1NameGte;
  /**
   * 物流渠道的物流渠道 比较(lt)
   */
  private String logisticsChannel1NameLt;
  /**
   * 物流渠道的物流渠道 比较(lte)
   */
  private String logisticsChannel1NameLte;
  /**
   * 物流渠道的物流渠道 比较(contains)
   */
  private String logisticsChannel1NameContains;
  /**
   * 物流渠道的物流渠道 比较(notcontains)
   */
  private String logisticsChannel1NameNotcontains;
  /**
   * 物流渠道的物流渠道 比较(startswith)
   */
  private String logisticsChannel1NameStartswith;
  /**
   * 物流渠道的物流渠道 比较(endswith)
   */
  private String logisticsChannel1NameEndswith;
  /**
   * 物流渠道的物流渠道 比较(isnull)
   */
  private Boolean logisticsChannel1NameIsnull;
  /**
   * 物流渠道的物流渠道 比较(isnotnull)
   */
  private Boolean logisticsChannel1NameIsnotnull;

  /**
   * 物流渠道(范围搜索)
   */
  private List<Long> logisticsChannel1InList;

  /**
   * 计费规则(模糊搜索)
   */
  private String billingrules;

  /**
   * 计费规则 比较(eq)
   */
  private String billingrulesEq;
  /**
   * 计费规则 比较(neq)
   */
  private String billingrulesNeq;
  /**
   * 计费规则 比较(gt)
   */
  private String billingrulesGt;
  /**
   * 计费规则 比较(gte)
   */
  private String billingrulesGte;
  /**
   * 计费规则 比较(lt)
   */
  private String billingrulesLt;
  /**
   * 计费规则 比较(lte)
   */
  private String billingrulesLte;
  /**
   * 计费规则 比较(contains)
   */
  private String billingrulesContains;
  /**
   * 计费规则 比较(notcontains)
   */
  private String billingrulesNotcontains;
  /**
   * 计费规则 比较(startswith)
   */
  private String billingrulesStartswith;
  /**
   * 计费规则 比较(endswith)
   */
  private String billingrulesEndswith;
  /**
   * 计费规则 比较(isnull)
   */
  private Boolean billingrulesIsnull;
  /**
   * 计费规则 比较(isnotnull)
   */
  private Boolean billingrulesIsnotnull;

  /**
   * 计费规则(精确搜索)
   */
  private List<String> billingrulesInList;

  /**
   * 材积参数(模糊搜索)
   */
  private String volumeparame;

  /**
   * 材积参数 比较(eq)
   */
  private String volumeparameEq;
  /**
   * 材积参数 比较(neq)
   */
  private String volumeparameNeq;
  /**
   * 材积参数 比较(gt)
   */
  private String volumeparameGt;
  /**
   * 材积参数 比较(gte)
   */
  private String volumeparameGte;
  /**
   * 材积参数 比较(lt)
   */
  private String volumeparameLt;
  /**
   * 材积参数 比较(lte)
   */
  private String volumeparameLte;
  /**
   * 材积参数 比较(contains)
   */
  private String volumeparameContains;
  /**
   * 材积参数 比较(notcontains)
   */
  private String volumeparameNotcontains;
  /**
   * 材积参数 比较(startswith)
   */
  private String volumeparameStartswith;
  /**
   * 材积参数 比较(endswith)
   */
  private String volumeparameEndswith;
  /**
   * 材积参数 比较(isnull)
   */
  private Boolean volumeparameIsnull;
  /**
   * 材积参数 比较(isnotnull)
   */
  private Boolean volumeparameIsnotnull;

  /**
   * 材积参数(精确搜索)
   */
  private List<String> volumeparameInList;

  /**
   * 收件方式
   */
  private String receivingmethod;

  /**
   * 收件方式 比较(eq)
   */
  private String receivingmethodEq;
  /**
   * 收件方式 比较(neq)
   */
  private String receivingmethodNeq;
  /**
   * 收件方式 比较(gt)
   */
  private String receivingmethodGt;
  /**
   * 收件方式 比较(gte)
   */
  private String receivingmethodGte;
  /**
   * 收件方式 比较(lt)
   */
  private String receivingmethodLt;
  /**
   * 收件方式 比较(lte)
   */
  private String receivingmethodLte;
  /**
   * 收件方式 比较(contains)
   */
  private String receivingmethodContains;
  /**
   * 收件方式 比较(notcontains)
   */
  private String receivingmethodNotcontains;
  /**
   * 收件方式 比较(startswith)
   */
  private String receivingmethodStartswith;
  /**
   * 收件方式 比较(endswith)
   */
  private String receivingmethodEndswith;
  /**
   * 收件方式 比较(isnull)
   */
  private Boolean receivingmethodIsnull;
  /**
   * 收件方式 比较(isnotnull)
   */
  private Boolean receivingmethodIsnotnull;

  /**
   * 收件方式(精确搜索)
   */
  private List<String> receivingmethodInList;

  /**
   * 最早揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectiontimeStart;

  /**
   * 最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectiontimeEnd;

  /**
   * 揽收时间 比较(eq)
   */
  private Date collectiontimeEq;
  /**
   * 揽收时间 比较(neq)
   */
  private Date collectiontimeNeq;
  /**
   * 揽收时间 比较(gt)
   */
  private Date collectiontimeGt;
  /**
   * 揽收时间 比较(gte)
   */
  private Date collectiontimeGte;
  /**
   * 揽收时间 比较(lt)
   */
  private Date collectiontimeLt;
  /**
   * 揽收时间 比较(lte)
   */
  private Date collectiontimeLte;
  /**
   * 揽收时间 比较(contains)
   */
  private Date collectiontimeContains;
  /**
   * 揽收时间 比较(notcontains)
   */
  private Date collectiontimeNotcontains;
  /**
   * 揽收时间 比较(startswith)
   */
  private Date collectiontimeStartswith;
  /**
   * 揽收时间 比较(endswith)
   */
  private Date collectiontimeEndswith;
  /**
   * 揽收时间 比较(isnull)
   */
  private Boolean collectiontimeIsnull;
  /**
   * 揽收时间 比较(isnotnull)
   */
  private Boolean collectiontimeIsnotnull;

  /**
   * 一般贸易
   */
  private String generaltrading;

  /**
   * 一般贸易 比较(eq)
   */
  private String generaltradingEq;
  /**
   * 一般贸易 比较(neq)
   */
  private String generaltradingNeq;
  /**
   * 一般贸易 比较(gt)
   */
  private String generaltradingGt;
  /**
   * 一般贸易 比较(gte)
   */
  private String generaltradingGte;
  /**
   * 一般贸易 比较(lt)
   */
  private String generaltradingLt;
  /**
   * 一般贸易 比较(lte)
   */
  private String generaltradingLte;
  /**
   * 一般贸易 比较(contains)
   */
  private String generaltradingContains;
  /**
   * 一般贸易 比较(notcontains)
   */
  private String generaltradingNotcontains;
  /**
   * 一般贸易 比较(startswith)
   */
  private String generaltradingStartswith;
  /**
   * 一般贸易 比较(endswith)
   */
  private String generaltradingEndswith;
  /**
   * 一般贸易 比较(isnull)
   */
  private Boolean generaltradingIsnull;
  /**
   * 一般贸易 比较(isnotnull)
   */
  private Boolean generaltradingIsnotnull;

  /**
   * 一般贸易(精确搜索)
   */
  private List<String> generaltradingInList;

  /**
   * 包税
   */
  private String taxgrossup;

  /**
   * 包税 比较(eq)
   */
  private String taxgrossupEq;
  /**
   * 包税 比较(neq)
   */
  private String taxgrossupNeq;
  /**
   * 包税 比较(gt)
   */
  private String taxgrossupGt;
  /**
   * 包税 比较(gte)
   */
  private String taxgrossupGte;
  /**
   * 包税 比较(lt)
   */
  private String taxgrossupLt;
  /**
   * 包税 比较(lte)
   */
  private String taxgrossupLte;
  /**
   * 包税 比较(contains)
   */
  private String taxgrossupContains;
  /**
   * 包税 比较(notcontains)
   */
  private String taxgrossupNotcontains;
  /**
   * 包税 比较(startswith)
   */
  private String taxgrossupStartswith;
  /**
   * 包税 比较(endswith)
   */
  private String taxgrossupEndswith;
  /**
   * 包税 比较(isnull)
   */
  private Boolean taxgrossupIsnull;
  /**
   * 包税 比较(isnotnull)
   */
  private Boolean taxgrossupIsnotnull;

  /**
   * 包税(精确搜索)
   */
  private List<String> taxgrossupInList;

  /**
   * 保险
   */
  private String insure;

  /**
   * 保险 比较(eq)
   */
  private String insureEq;
  /**
   * 保险 比较(neq)
   */
  private String insureNeq;
  /**
   * 保险 比较(gt)
   */
  private String insureGt;
  /**
   * 保险 比较(gte)
   */
  private String insureGte;
  /**
   * 保险 比较(lt)
   */
  private String insureLt;
  /**
   * 保险 比较(lte)
   */
  private String insureLte;
  /**
   * 保险 比较(contains)
   */
  private String insureContains;
  /**
   * 保险 比较(notcontains)
   */
  private String insureNotcontains;
  /**
   * 保险 比较(startswith)
   */
  private String insureStartswith;
  /**
   * 保险 比较(endswith)
   */
  private String insureEndswith;
  /**
   * 保险 比较(isnull)
   */
  private Boolean insureIsnull;
  /**
   * 保险 比较(isnotnull)
   */
  private Boolean insureIsnotnull;

  /**
   * 保险(精确搜索)
   */
  private List<String> insureInList;

  /**
   * EORI(模糊搜索)
   */
  private String eori;

  /**
   * EORI 比较(eq)
   */
  private String eoriEq;
  /**
   * EORI 比较(neq)
   */
  private String eoriNeq;
  /**
   * EORI 比较(gt)
   */
  private String eoriGt;
  /**
   * EORI 比较(gte)
   */
  private String eoriGte;
  /**
   * EORI 比较(lt)
   */
  private String eoriLt;
  /**
   * EORI 比较(lte)
   */
  private String eoriLte;
  /**
   * EORI 比较(contains)
   */
  private String eoriContains;
  /**
   * EORI 比较(notcontains)
   */
  private String eoriNotcontains;
  /**
   * EORI 比较(startswith)
   */
  private String eoriStartswith;
  /**
   * EORI 比较(endswith)
   */
  private String eoriEndswith;
  /**
   * EORI 比较(isnull)
   */
  private Boolean eoriIsnull;
  /**
   * EORI 比较(isnotnull)
   */
  private Boolean eoriIsnotnull;

  /**
   * EORI(精确搜索)
   */
  private List<String> eoriInList;

  /**
   * VAT税号(模糊搜索)
   */
  private String vatduty;

  /**
   * VAT税号 比较(eq)
   */
  private String vatdutyEq;
  /**
   * VAT税号 比较(neq)
   */
  private String vatdutyNeq;
  /**
   * VAT税号 比较(gt)
   */
  private String vatdutyGt;
  /**
   * VAT税号 比较(gte)
   */
  private String vatdutyGte;
  /**
   * VAT税号 比较(lt)
   */
  private String vatdutyLt;
  /**
   * VAT税号 比较(lte)
   */
  private String vatdutyLte;
  /**
   * VAT税号 比较(contains)
   */
  private String vatdutyContains;
  /**
   * VAT税号 比较(notcontains)
   */
  private String vatdutyNotcontains;
  /**
   * VAT税号 比较(startswith)
   */
  private String vatdutyStartswith;
  /**
   * VAT税号 比较(endswith)
   */
  private String vatdutyEndswith;
  /**
   * VAT税号 比较(isnull)
   */
  private Boolean vatdutyIsnull;
  /**
   * VAT税号 比较(isnotnull)
   */
  private Boolean vatdutyIsnotnull;

  /**
   * VAT税号(精确搜索)
   */
  private List<String> vatdutyInList;

  /**
   * 自定义单号(模糊搜索)
   */
  private String customordernumber;

  /**
   * 自定义单号 比较(eq)
   */
  private String customordernumberEq;
  /**
   * 自定义单号 比较(neq)
   */
  private String customordernumberNeq;
  /**
   * 自定义单号 比较(gt)
   */
  private String customordernumberGt;
  /**
   * 自定义单号 比较(gte)
   */
  private String customordernumberGte;
  /**
   * 自定义单号 比较(lt)
   */
  private String customordernumberLt;
  /**
   * 自定义单号 比较(lte)
   */
  private String customordernumberLte;
  /**
   * 自定义单号 比较(contains)
   */
  private String customordernumberContains;
  /**
   * 自定义单号 比较(notcontains)
   */
  private String customordernumberNotcontains;
  /**
   * 自定义单号 比较(startswith)
   */
  private String customordernumberStartswith;
  /**
   * 自定义单号 比较(endswith)
   */
  private String customordernumberEndswith;
  /**
   * 自定义单号 比较(isnull)
   */
  private Boolean customordernumberIsnull;
  /**
   * 自定义单号 比较(isnotnull)
   */
  private Boolean customordernumberIsnotnull;

  /**
   * 自定义单号(精确搜索)
   */
  private List<String> customordernumberInList;

  /**
   * 分摊方式(模糊搜索)
   */
  private String allocationmethod;

  /**
   * 分摊方式 比较(eq)
   */
  private String allocationmethodEq;
  /**
   * 分摊方式 比较(neq)
   */
  private String allocationmethodNeq;
  /**
   * 分摊方式 比较(gt)
   */
  private String allocationmethodGt;
  /**
   * 分摊方式 比较(gte)
   */
  private String allocationmethodGte;
  /**
   * 分摊方式 比较(lt)
   */
  private String allocationmethodLt;
  /**
   * 分摊方式 比较(lte)
   */
  private String allocationmethodLte;
  /**
   * 分摊方式 比较(contains)
   */
  private String allocationmethodContains;
  /**
   * 分摊方式 比较(notcontains)
   */
  private String allocationmethodNotcontains;
  /**
   * 分摊方式 比较(startswith)
   */
  private String allocationmethodStartswith;
  /**
   * 分摊方式 比较(endswith)
   */
  private String allocationmethodEndswith;
  /**
   * 分摊方式 比较(isnull)
   */
  private Boolean allocationmethodIsnull;
  /**
   * 分摊方式 比较(isnotnull)
   */
  private Boolean allocationmethodIsnotnull;

  /**
   * 分摊方式(精确搜索)
   */
  private List<String> allocationmethodInList;

  /**
   * 货件id
   */
  private Long shipmentIds;

  /**
   * 最小货件id
   */
  private Long shipmentIdsMin;

  /**
   * 最大货件id
   */
  private Long shipmentIdsMax;

  /**
   * 货件id 比较(eq)
   */
  private Long shipmentIdsEq;
  /**
   * 货件id 比较(neq)
   */
  private Long shipmentIdsNeq;
  /**
   * 货件id 比较(gt)
   */
  private Long shipmentIdsGt;
  /**
   * 货件id 比较(gte)
   */
  private Long shipmentIdsGte;
  /**
   * 货件id 比较(lt)
   */
  private Long shipmentIdsLt;
  /**
   * 货件id 比较(lte)
   */
  private Long shipmentIdsLte;
  /**
   * 货件id 比较(contains)
   */
  private Long shipmentIdsContains;
  /**
   * 货件id 比较(notcontains)
   */
  private Long shipmentIdsNotcontains;
  /**
   * 货件id 比较(startswith)
   */
  private Long shipmentIdsStartswith;
  /**
   * 货件id 比较(endswith)
   */
  private Long shipmentIdsEndswith;
  /**
   * 货件id 比较(isnull)
   */
  private Boolean shipmentIdsIsnull;
  /**
   * 货件id 比较(isnotnull)
   */
  private Boolean shipmentIdsIsnotnull;

  /**
   * 净重量
   */
  private java.math.BigDecimal netWeight;

  /**
   * 最小净重量
   */
  private java.math.BigDecimal netWeightMin;

  /**
   * 最大净重量
   */
  private java.math.BigDecimal netWeightMax;

  /**
   * 净重量 比较(eq)
   */
  private java.math.BigDecimal netWeightEq;
  /**
   * 净重量 比较(neq)
   */
  private java.math.BigDecimal netWeightNeq;
  /**
   * 净重量 比较(gt)
   */
  private java.math.BigDecimal netWeightGt;
  /**
   * 净重量 比较(gte)
   */
  private java.math.BigDecimal netWeightGte;
  /**
   * 净重量 比较(lt)
   */
  private java.math.BigDecimal netWeightLt;
  /**
   * 净重量 比较(lte)
   */
  private java.math.BigDecimal netWeightLte;
  /**
   * 净重量 比较(contains)
   */
  private java.math.BigDecimal netWeightContains;
  /**
   * 净重量 比较(notcontains)
   */
  private java.math.BigDecimal netWeightNotcontains;
  /**
   * 净重量 比较(startswith)
   */
  private java.math.BigDecimal netWeightStartswith;
  /**
   * 净重量 比较(endswith)
   */
  private java.math.BigDecimal netWeightEndswith;
  /**
   * 净重量 比较(isnull)
   */
  private Boolean netWeightIsnull;
  /**
   * 净重量 比较(isnotnull)
   */
  private Boolean netWeightIsnotnull;

  /**
   * 毛重量
   */
  private java.math.BigDecimal grossWeight;

  /**
   * 最小毛重量
   */
  private java.math.BigDecimal grossWeightMin;

  /**
   * 最大毛重量
   */
  private java.math.BigDecimal grossWeightMax;

  /**
   * 毛重量 比较(eq)
   */
  private java.math.BigDecimal grossWeightEq;
  /**
   * 毛重量 比较(neq)
   */
  private java.math.BigDecimal grossWeightNeq;
  /**
   * 毛重量 比较(gt)
   */
  private java.math.BigDecimal grossWeightGt;
  /**
   * 毛重量 比较(gte)
   */
  private java.math.BigDecimal grossWeightGte;
  /**
   * 毛重量 比较(lt)
   */
  private java.math.BigDecimal grossWeightLt;
  /**
   * 毛重量 比较(lte)
   */
  private java.math.BigDecimal grossWeightLte;
  /**
   * 毛重量 比较(contains)
   */
  private java.math.BigDecimal grossWeightContains;
  /**
   * 毛重量 比较(notcontains)
   */
  private java.math.BigDecimal grossWeightNotcontains;
  /**
   * 毛重量 比较(startswith)
   */
  private java.math.BigDecimal grossWeightStartswith;
  /**
   * 毛重量 比较(endswith)
   */
  private java.math.BigDecimal grossWeightEndswith;
  /**
   * 毛重量 比较(isnull)
   */
  private Boolean grossWeightIsnull;
  /**
   * 毛重量 比较(isnotnull)
   */
  private Boolean grossWeightIsnotnull;

  /**
   * 总体积
   */
  private java.math.BigDecimal totalVolume;

  /**
   * 最小总体积
   */
  private java.math.BigDecimal totalVolumeMin;

  /**
   * 最大总体积
   */
  private java.math.BigDecimal totalVolumeMax;

  /**
   * 总体积 比较(eq)
   */
  private java.math.BigDecimal totalVolumeEq;
  /**
   * 总体积 比较(neq)
   */
  private java.math.BigDecimal totalVolumeNeq;
  /**
   * 总体积 比较(gt)
   */
  private java.math.BigDecimal totalVolumeGt;
  /**
   * 总体积 比较(gte)
   */
  private java.math.BigDecimal totalVolumeGte;
  /**
   * 总体积 比较(lt)
   */
  private java.math.BigDecimal totalVolumeLt;
  /**
   * 总体积 比较(lte)
   */
  private java.math.BigDecimal totalVolumeLte;
  /**
   * 总体积 比较(contains)
   */
  private java.math.BigDecimal totalVolumeContains;
  /**
   * 总体积 比较(notcontains)
   */
  private java.math.BigDecimal totalVolumeNotcontains;
  /**
   * 总体积 比较(startswith)
   */
  private java.math.BigDecimal totalVolumeStartswith;
  /**
   * 总体积 比较(endswith)
   */
  private java.math.BigDecimal totalVolumeEndswith;
  /**
   * 总体积 比较(isnull)
   */
  private Boolean totalVolumeIsnull;
  /**
   * 总体积 比较(isnotnull)
   */
  private Boolean totalVolumeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
